package Utilitarios;

import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;
import java.util.Vector;
import javax.swing.table.AbstractTableModel;
import model.Processo;
import model.Setor;
import model.Tramitacao;

/**
 * @author eversonpaulo
 */
public class JtableTramitacao extends AbstractTableModel {

    private List<Tramitacao> linhas;
    protected Vector dataVector;

    /**
     * The <code>Vector</code> of column identifiers.
     */
    protected Vector columnIdentifiers;

    public JtableTramitacao() {
        linhas = new ArrayList<Tramitacao>();
    }

    public JtableTramitacao(List<Tramitacao> listaTramita) {
        linhas = new ArrayList<Tramitacao>(listaTramita);
    }

    private String[] colunas = new String[]{"Numero Processo", "Setor", "Assunto", "Recebido"};
//, "ID", "Data"
    private static final int NumeroProcesso = 0;
    private static final int Setor = 1;
    private static final int Assunto = 2;
    private static final int Recebido = 3;
//    private static final int ID = 4;
//    private static final int Data = 5;

    @Override
    public int getRowCount() {
        return linhas.size();
    }

    @Override
    public int getColumnCount() {
        return colunas.length;
    }

    @Override
    public String getColumnName(int columnIndex) {
        return colunas[columnIndex];
    }

    @Override
    public Class<?> getColumnClass(int columnIndex) {
        switch (columnIndex) {
            case NumeroProcesso:
                return String.class;
            case Setor:
                return String.class;
            case Assunto:
                return String.class;
            case Recebido:
                return Boolean.class;
//            case ID:
//                return int.class;
//            case Data:
//                return Calendar.class;
            default:
                // Não deve ocorrer, pois só existem 2 colunas
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
    }

    @Override
    public boolean isCellEditable(int rowIndex, int columnIndex) {
        return columnIndex == Recebido;
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        Tramitacao tramits = linhas.get(rowIndex);
//        Processo pros= linhas.get(rowIndex);
        switch (columnIndex) {
            case NumeroProcesso:
                return tramits.getProcesso().getNumeroProcesso();
            case Setor:
                return tramits.getSetorReceb();
            case Assunto:
                return tramits.getProcesso().getAssunto();
            case Recebido:
                return tramits.isRecebido();
//            case ID:
//                return tramits.getId_Tramitacao();
//            case Data:
//                return tramits.getDataEnca();
            default:
                // Não deve ocorrer, pois só existem 2 colunas
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        // Pega o sócio referente a linha especificada.
        Tramitacao tramits = linhas.get(rowIndex);
        switch (columnIndex) {
            case NumeroProcesso:
                tramits.getProcesso().setNumeroProcesso((String) aValue);
                break;
            case Setor:
                tramits.setSetorReceb((Setor) aValue);
                break;
            case Assunto:
                tramits.getProcesso().getAssunto().setAssunto((String) aValue);
                break;
            case Recebido:
                tramits.setRecebido((Boolean) aValue);
                break;
//            case ID:
//                tramits.setId_Tramitacao((int) aValue);
//                break;
//            case Data:
//                tramits.setDataEnca((Calendar) aValue);
//                break;

            default:
                // Não deve ocorrer, pois só existem 2 colunas
                throw new IndexOutOfBoundsException("columnIndex out of bounds");
        }
        fireTableCellUpdated(rowIndex, columnIndex); // Notifica a atualização da célula
    }

    // Retorna o sócio referente a linha especificada
    public Tramitacao getProcesso(int indiceLinha) {
        return linhas.get(indiceLinha);
    }

    // Adiciona o sócio especificado ao modelo
    public void addTamitacao(Tramitacao tramits) {
        // Adiciona o registro.
        linhas.add(tramits);
        // Pega a quantidade de registros e subtrai 1 para
        // achar o último índice. A subtração é necessária
        // porque os índices começam em zero.
        int ultimoIndice = getRowCount() - 1;
        // Notifica a mudança.
        fireTableRowsInserted(ultimoIndice, ultimoIndice);
    }

    // Remove o sócio da linha especificada.
    public void removeTramits(int indiceLinha) {

        // Remove o registro.
        linhas.remove(indiceLinha);
        // Notifica a mudança.
        fireTableRowsDeleted(indiceLinha, indiceLinha);
    }

    // Adiciona uma lista de sócios no final da lista.
    public void addListaDeTramits(List<Tramitacao> tramits) {
        // Pega o tamanho antigo da tabela, que servirá
        // como índice para o primeiro dos novos registros
        int indice = getRowCount();
        // Adiciona os registros.
        linhas.addAll(tramits);
        // Notifica a mudança.
        fireTableRowsInserted(indice, indice + tramits.size());
    }

    // Remove todos os registros.
    public void limpar() {
        // Remove todos os elementos da lista de sócios.
        linhas.clear();
        // Notifica a mudança.
        fireTableDataChanged();
    }

    public void setNumRows(int rowCount) {
        int old = getRowCount();
        if (old == rowCount) {
            return;
        }
        dataVector.setSize(rowCount);
        if (rowCount <= old) {
            fireTableRowsDeleted(rowCount, old - 1);
        } else {
            justifyRows(old, rowCount);
            fireTableRowsInserted(old, rowCount - 1);
        }
    }

    private void justifyRows(int from, int to) {
        // Sometimes the DefaultTableModel is subclassed
        // instead of the AbstractTableModel by mistake.
        // Set the number of rows for the case when getRowCount
        // is overridden.
        dataVector.setSize(getRowCount());

        for (int i = from; i < to; i++) {
            if (dataVector.elementAt(i) == null) {
                dataVector.setElementAt(new Vector(), i);
            }
            ((Vector) dataVector.elementAt(i)).setSize(getColumnCount());
        }
    }
}
